package com.xiaowu.system.service.question.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.pagehelper.PageHelper;
import com.xiaowu.common.core.constants.Constants;
import com.xiaowu.common.core.domain.TableDataInfo;
import com.xiaowu.common.core.enums.ResultCode;
import com.xiaowu.common.core.utils.JwtUtils;
import com.xiaowu.common.redis.service.RedisService;
import com.xiaowu.common.security.exception.ServiceException;
import com.xiaowu.system.domain.question.Question;
import com.xiaowu.system.domain.question.dto.QuestionAddDTO;
import com.xiaowu.system.domain.question.dto.QuestionEditDTO;
import com.xiaowu.system.domain.question.dto.QuestionQueryDTO;
import com.xiaowu.system.domain.question.es.QuestionES;
import com.xiaowu.system.domain.question.vo.QuestionDetailVO;
import com.xiaowu.system.domain.question.vo.QuestionVO;
import com.xiaowu.system.elasticsearch.QuestionRepository;
import com.xiaowu.system.manager.QuestionCacheManager;
import com.xiaowu.system.mapper.question.QuestionMapper;
import com.xiaowu.system.service.question.IQuestionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;


@Service
public class QuestionServiceImpl implements IQuestionService {

    // 注入QuestionMapper
    @Autowired
    QuestionMapper questionMapper;

    @Autowired
    QuestionCacheManager questionCacheManager;

    // 注入QuestionRepository
    @Autowired
    QuestionRepository questionRepository;


    // 根据查询条件查询问题列表
    @Override
    public List<QuestionVO> list(QuestionQueryDTO questionQueryDTO) {
        // 获取排除的id字符串
        String excludeIdStr = questionQueryDTO.getExcludeIdStr();
        // 如果排除的id字符串不为空
        if (StrUtil.isNotEmpty(excludeIdStr)) {
            // 将排除的id字符串按分隔符分割成数组
            String[] excludeIdArr = excludeIdStr.split(Constants.SPLIT_SEM);
            // 将数组中的字符串转换为Long类型，并收集到Set集合中
            Set<Long> excludeIdSet = Arrays.stream(excludeIdArr)
                    .map(Long::valueOf)
                    .collect(Collectors.toSet());
            // 将Set集合设置到查询条件中
            questionQueryDTO.setExcludeIdSet(excludeIdSet);
        }
        // 设置分页参数
        PageHelper.startPage(questionQueryDTO.getPageNum(), questionQueryDTO.getPageSize());
        // 查询问题列表
        return questionMapper.selectQuestionList(questionQueryDTO);
    }

    // 添加问题
    @Override
    public boolean add(QuestionAddDTO questionAddDTO) {
        // 根据标题查询问题列表
        List<Question> questionList = questionMapper.selectList(new LambdaQueryWrapper<Question>()
                .eq(Question::getTitle, questionAddDTO.getTitle()));
        // 如果问题列表不为空，说明标题已存在
        if (CollectionUtil.isNotEmpty(questionList)) {
            // 抛出异常
            throw new ServiceException(ResultCode.FAILED_ALREADY_EXISTS);
        }
        // 创建问题对象
        Question question = new Question();
        // 将DTO中的属性值复制到问题对象中
        BeanUtil.copyProperties(questionAddDTO, question);
        // 插入问题
        int insert = questionMapper.insert(question);
        // 如果插入失败
        if (insert <= 0) {
            // 返回false
            return false;
        }
        // 创建问题ES对象
        QuestionES questionES = new QuestionES();
        // 将问题对象中的属性值复制到问题ES对象中
        BeanUtil.copyProperties(question, questionES);
        // 保存问题ES对象
        questionRepository.save(questionES);
        // 缓存
        questionCacheManager.addCache(questionES.getQuestionId());
        // 返回true
        return true;
    }

    // 根据问题id查询问题详情
    @Override
    public QuestionDetailVO detail(Long questionId) {
        // 根据问题id查询问题
        Question question = questionMapper.selectById(questionId);
        // 如果问题不存在
        if (question == null) {
            // 抛出异常
            throw new ServiceException(ResultCode.FAILED_NOT_EXISTS);
        }
        // 创建问题详情VO对象
        QuestionDetailVO questionDetailVO = new QuestionDetailVO();
        // 将问题对象中的属性值复制到问题详情VO对象中
        BeanUtil.copyProperties(question, questionDetailVO);
        // 返回问题详情VO对象
        return questionDetailVO;
    }

    // 编辑问题
    @Override
    public int edit(QuestionEditDTO questionEditDTO) {
        // 根据问题id查询问题
        Question oldQuestion = questionMapper.selectById(questionEditDTO.getQuestionId());
        // 如果问题不存在
        if (oldQuestion == null) {
            // 抛出异常
            throw new ServiceException(ResultCode.FAILED_NOT_EXISTS);
        }
        // 设置问题对象的属性值
        oldQuestion.setTitle(questionEditDTO.getTitle());
        oldQuestion.setDifficulty(questionEditDTO.getDifficulty());
        oldQuestion.setTimeLimit(questionEditDTO.getTimeLimit());
        oldQuestion.setSpaceLimit(questionEditDTO.getSpaceLimit());
        oldQuestion.setContent(questionEditDTO.getContent());
        oldQuestion.setQuestionCase(questionEditDTO.getQuestionCase());
        oldQuestion.setDefaultCode(questionEditDTO.getDefaultCode());
        oldQuestion.setMainFuc(questionEditDTO.getMainFuc());
        // 创建问题ES对象
        QuestionES questionES = new QuestionES();
        // 将问题对象中的属性值复制到问题ES对象中
        BeanUtil.copyProperties(oldQuestion, questionES);
        // 保存问题ES对象
        questionRepository.save(questionES);
        // 更新问题
        return questionMapper.updateById(oldQuestion);
    }

    // 根据问题id删除问题
    @Override
    public int delete(Long questionId) {
        // 根据问题id查询问题
        Question question = questionMapper.selectById(questionId);
        // 如果问题不存在
        if (question == null) {
            // 抛出异常
            throw new ServiceException(ResultCode.FAILED_NOT_EXISTS);
        }
        // 删除问题ES对象
        questionRepository.deleteById(questionId);
        // 删除缓存
        questionCacheManager.deleteCache(questionId);
        // 删除问题
        return questionMapper.deleteById(questionId);
    }
}
